<!DOCTYPE html>
<html lang="zh-CN">
    <head>
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <meta name="robots" content="noodp" />
        <title>二、MySQL一条记录怎么存储的？ - L_B__</title><meta name="referrer" content="no-referrer">
<meta name="description" content="二、MySQL一条记录怎么存储的？"><meta property="og:title" content="二、MySQL一条记录怎么存储的？" />
<meta property="og:description" content="二、MySQL一条记录怎么存储的？" />
<meta property="og:type" content="article" />
<meta property="og:url" content="https://acking-you.github.io/posts/%E4%BA%8Cmysql%E4%B8%80%E6%9D%A1%E8%AE%B0%E5%BD%95%E6%80%8E%E4%B9%88%E5%AD%98%E5%82%A8%E7%9A%84/" /><meta property="og:image" content="https://acking-you.github.io/logo.png"/><meta property="article:section" content="posts" />
<meta property="article:published_time" content="2023-05-27T00:00:00+00:00" />
<meta property="article:modified_time" content="2023-05-27T00:00:00+00:00" />

<meta name="twitter:card" content="summary_large_image"/>
<meta name="twitter:image" content="https://acking-you.github.io/logo.png"/>

<meta name="twitter:title" content="二、MySQL一条记录怎么存储的？"/>
<meta name="twitter:description" content="二、MySQL一条记录怎么存储的？"/>
<meta name="application-name" content="FeelIt">
<meta name="apple-mobile-web-app-title" content="FeelIt"><meta name="theme-color" content="#ffffff"><meta name="msapplication-TileColor" content="#da532c"><link rel="canonical" href="https://acking-you.github.io/posts/%E4%BA%8Cmysql%E4%B8%80%E6%9D%A1%E8%AE%B0%E5%BD%95%E6%80%8E%E4%B9%88%E5%AD%98%E5%82%A8%E7%9A%84/" /><link rel="prev" href="https://acking-you.github.io/posts/%E5%A4%9A%E7%BA%BF%E7%A8%8B%E5%86%B2%E7%AA%81%E4%BA%86%E6%80%8E%E4%B9%88%E5%8A%9E/" /><link rel="next" href="https://acking-you.github.io/posts/%E8%BF%9B%E7%A8%8B%E9%97%B4%E9%80%9A%E4%BF%A1%E6%96%B9%E5%BC%8F/" /><link rel="stylesheet" href="/css/page.min.css"><link rel="stylesheet" href="/css/home.min.css"><script type="application/ld+json">
    {
        "@context": "http://schema.org",
        "@type": "BlogPosting",
        "headline": "二、MySQL一条记录怎么存储的？",
        "inLanguage": "zh-CN",
        "mainEntityOfPage": {
            "@type": "WebPage",
            "@id": "https:\/\/acking-you.github.io\/posts\/%E4%BA%8Cmysql%E4%B8%80%E6%9D%A1%E8%AE%B0%E5%BD%95%E6%80%8E%E4%B9%88%E5%AD%98%E5%82%A8%E7%9A%84\/"
        },"genre": "posts","keywords": "二、MySQL一条记录怎么存储的？","wordcount":  7944 ,
        "url": "https:\/\/acking-you.github.io\/posts\/%E4%BA%8Cmysql%E4%B8%80%E6%9D%A1%E8%AE%B0%E5%BD%95%E6%80%8E%E4%B9%88%E5%AD%98%E5%82%A8%E7%9A%84\/","datePublished": "2023-05-27T00:00:00+00:00","dateModified": "2023-05-27T00:00:00+00:00","publisher": {
            "@type": "Organization",
            "name": "作者"},"author": {
                "@type": "Person",
                "name": "作者"
            },"description": "二、MySQL一条记录怎么存储的？"
    }
    </script></head><body data-header-desktop="auto" data-header-mobile="auto"><script>(window.localStorage && localStorage.getItem('theme') ? localStorage.getItem('theme') === 'dark' : ('auto' === 'auto' ? window.matchMedia('(prefers-color-scheme: dark)').matches : 'auto' === 'dark')) && document.body.setAttribute('theme', 'dark');</script>

        <div id="mask"></div><div class="wrapper"><header class="desktop" id="header-desktop">
    <div class="header-wrapper">
        <div class="header-title">
            <a href="/" title="L_B__">L_B__</a>
        </div>
        <div class="menu">
            <div class="menu-inner"><a class="menu-item" href="/posts/"> 文章 </a><a class="menu-item" href="/tags/"> 标签 </a><a class="menu-item" href="/categories/"> 分类 </a><span class="menu-item delimiter"></span><span class="menu-item search" id="search-desktop">
                        <input type="text" placeholder="搜索文章标题或内容..." id="search-input-desktop">
                        <a href="#" class="search-button search-toggle" id="search-toggle-desktop" title="搜索">
                            <i class="fas fa-search fa-fw"></i>
                        </a>
                        <a href="#" class="search-button search-clear" id="search-clear-desktop" title="清空">
                            <i class="fas fa-times-circle fa-fw"></i>
                        </a>
                        <span class="search-button search-loading" id="search-loading-desktop">
                            <i class="fas fa-spinner fa-fw fa-spin"></i>
                        </span>
                    </span><a href="javascript:void(0);" class="menu-item theme-switch" title="切换主题">
                    <i class="fas fa-adjust fa-fw"></i>
                </a>
            </div>
        </div>
    </div>
</header><header class="mobile" id="header-mobile">
    <div class="header-container">
        <div class="header-wrapper">
            <div class="header-title">
                <a href="/" title="L_B__">L_B__</a>
            </div>
            <div class="menu-toggle" id="menu-toggle-mobile">
                <span></span><span></span><span></span>
            </div>
        </div>
        <div class="menu" id="menu-mobile"><div class="search-wrapper">
                    <div class="search mobile" id="search-mobile">
                        <input type="text" placeholder="搜索文章标题或内容..." id="search-input-mobile">
                        <a href="#" class="search-button search-toggle" id="search-toggle-mobile" title="搜索">
                            <i class="fas fa-search fa-fw"></i>
                        </a>
                        <a href="#" class="search-button search-clear" id="search-clear-mobile" title="清空">
                            <i class="fas fa-times-circle fa-fw"></i>
                        </a>
                        <span class="search-button search-loading" id="search-loading-mobile">
                            <i class="fas fa-spinner fa-fw fa-spin"></i>
                        </span>
                    </div>
                    <a href="#" class="search-cancel" id="search-cancel-mobile">
                        取消
                    </a>
                </div><a class="menu-item" href="/posts/" title="">文章</a><a class="menu-item" href="/tags/" title="">标签</a><a class="menu-item" href="/categories/" title="">分类</a><div class="menu-item"><a href="javascript:void(0);" class="theme-switch" title="切换主题">
                    <i class="fas fa-adjust fa-fw"></i>
                </a>
            </div></div>
    </div>
</header><div class="search-dropdown desktop">
    <div id="search-dropdown-desktop"></div>
</div>
<div class="search-dropdown mobile">
    <div id="search-dropdown-mobile"></div>
</div><main class="main">
                <div class="container"><div class="toc" id="toc-auto">
            <h2 class="toc-title">目录</h2>
            <div class="toc-content" id="toc-content-auto"></div>
        </div><article class="page single" data-toc="disable"><div class="featured-image"><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://img-blog.csdnimg.cn/img_convert/daefa95e021376b822b5938e65b8252b.png#pic_center"
        data-srcset="https://img-blog.csdnimg.cn/img_convert/daefa95e021376b822b5938e65b8252b.png#pic_center, https://img-blog.csdnimg.cn/img_convert/daefa95e021376b822b5938e65b8252b.png#pic_center 1.5x, https://img-blog.csdnimg.cn/img_convert/daefa95e021376b822b5938e65b8252b.png#pic_center 2x"
        data-sizes="auto"
        alt="https://img-blog.csdnimg.cn/img_convert/daefa95e021376b822b5938e65b8252b.png#pic_center"
        title="二、MySQL一条记录怎么存储的？" /></div><div class="single-card" data-image="true"><h2 class="single-title animated flipInX">二、MySQL一条记录怎么存储的？</h2><div class="post-meta">
                <div class="post-meta-line"><span class="post-author"><a href="/" title="Author" rel=" author" class="author"><i class="fas fa-user-circle fa-fw"></i>作者</a></span>&nbsp;<span class="post-category">出版于  <a href="/categories/mysql%E5%9F%BA%E7%A1%80%E7%AF%87/"><i class="far fa-folder fa-fw"></i>MySQL基础篇</a></span></div>
                <div class="post-meta-line"><span><i class="far fa-calendar-alt fa-fw"></i>&nbsp;<time datetime="2023-05-27">2023-05-27</time></span>&nbsp;<span><i class="fas fa-pencil-alt fa-fw"></i>&nbsp;约 7944 字</span>&nbsp;
                    <span><i class="far fa-clock fa-fw"></i>&nbsp;预计阅读 16 分钟</span>&nbsp;</div>
            </div>
            
            <hr><div class="details toc" id="toc-static"  data-kept="">
                    <div class="details-summary toc-title">
                        <span>目录</span>
                        <span><i class="details-icon fas fa-angle-right"></i></span>
                    </div>
                    <div class="details-content toc-content" id="toc-content-static"><nav id="TableOfContents">
  <ul>
    <li><a href="#httpsxiaolincodingcommysqlbaserow_formathtmlmysql-的数据存放在哪个文件mysql-的数据存放在哪个文件"><a href="https://xiaolincoding.com/mysql/base/row_format.html#mysql-%E7%9A%84%E6%95%B0%E6%8D%AE%E5%AD%98%E6%94%BE%E5%9C%A8%E5%93%AA%E4%B8%AA%E6%96%87%E4%BB%B6">#</a>MySQL 的数据存放在哪个文件？</a>
      <ul>
        <li><a href="#httpsxiaolincodingcommysqlbaserow_formathtml表空间文件的结构是怎么样的表空间文件的结构是怎么样的"><a href="https://xiaolincoding.com/mysql/base/row_format.html#%E8%A1%A8%E7%A9%BA%E9%97%B4%E6%96%87%E4%BB%B6%E7%9A%84%E7%BB%93%E6%9E%84%E6%98%AF%E6%80%8E%E4%B9%88%E6%A0%B7%E7%9A%84">#</a>表空间文件的结构是怎么样的？</a></li>
      </ul>
    </li>
    <li><a href="#httpsxiaolincodingcommysqlbaserow_formathtmlinnodb-行格式有哪些innodb-行格式有哪些"><a href="https://xiaolincoding.com/mysql/base/row_format.html#innodb-%E8%A1%8C%E6%A0%BC%E5%BC%8F%E6%9C%89%E5%93%AA%E4%BA%9B">#</a>InnoDB 行格式有哪些？</a></li>
    <li><a href="#httpsxiaolincodingcommysqlbaserow_formathtmlcompact-行格式长什么样compact-行格式长什么样"><a href="https://xiaolincoding.com/mysql/base/row_format.html#compact-%E8%A1%8C%E6%A0%BC%E5%BC%8F%E9%95%BF%E4%BB%80%E4%B9%88%E6%A0%B7">#</a>COMPACT 行格式长什么样？</a>
      <ul>
        <li><a href="#httpsxiaolincodingcommysqlbaserow_formathtml记录的额外信息记录的额外信息"><a href="https://xiaolincoding.com/mysql/base/row_format.html#%E8%AE%B0%E5%BD%95%E7%9A%84%E9%A2%9D%E5%A4%96%E4%BF%A1%E6%81%AF">#</a>记录的额外信息</a></li>
        <li><a href="#httpsxiaolincodingcommysqlbaserow_formathtml记录的真实数据记录的真实数据"><a href="https://xiaolincoding.com/mysql/base/row_format.html#%E8%AE%B0%E5%BD%95%E7%9A%84%E7%9C%9F%E5%AE%9E%E6%95%B0%E6%8D%AE">#</a>记录的真实数据</a></li>
      </ul>
    </li>
    <li><a href="#httpsxiaolincodingcommysqlbaserow_formathtmlvarchar-n-中-n-最大取值为多少varcharn-中-n-最大取值为多少"><a href="https://xiaolincoding.com/mysql/base/row_format.html#varchar-n-%E4%B8%AD-n-%E6%9C%80%E5%A4%A7%E5%8F%96%E5%80%BC%E4%B8%BA%E5%A4%9A%E5%B0%91">#</a>varchar(n) 中 n 最大取值为多少？</a>
      <ul>
        <li><a href="#httpsxiaolincodingcommysqlbaserow_formathtml单字段的情况单字段的情况"><a href="https://xiaolincoding.com/mysql/base/row_format.html#%E5%8D%95%E5%AD%97%E6%AE%B5%E7%9A%84%E6%83%85%E5%86%B5">#</a>单字段的情况</a></li>
        <li><a href="#httpsxiaolincodingcommysqlbaserow_formathtml多字段的情况多字段的情况"><a href="https://xiaolincoding.com/mysql/base/row_format.html#%E5%A4%9A%E5%AD%97%E6%AE%B5%E7%9A%84%E6%83%85%E5%86%B5">#</a>多字段的情况</a></li>
      </ul>
    </li>
    <li><a href="#httpsxiaolincodingcommysqlbaserow_formathtml行溢出后-mysql-是怎么处理的行溢出后mysql-是怎么处理的"><a href="https://xiaolincoding.com/mysql/base/row_format.html#%E8%A1%8C%E6%BA%A2%E5%87%BA%E5%90%8E-mysql-%E6%98%AF%E6%80%8E%E4%B9%88%E5%A4%84%E7%90%86%E7%9A%84">#</a>行溢出后，MySQL 是怎么处理的？</a></li>
    <li><a href="#httpsxiaolincodingcommysqlbaserow_formathtml总结总结"><a href="https://xiaolincoding.com/mysql/base/row_format.html#%E6%80%BB%E7%BB%93">#</a>总结</a></li>
  </ul>
</nav></div>
                </div><div class="content" id="content"><h1 id="mysql-一行记录是怎么存储的">MySQL 一行记录是怎么存储的？</h1>
<p>有人被问到这么个问题：</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%AF%BB%E8%80%85%E9%97%AE%E9%A2%98.jpeg"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%AF%BB%E8%80%85%E9%97%AE%E9%A2%98.jpeg, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%AF%BB%E8%80%85%E9%97%AE%E9%A2%98.jpeg 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%AF%BB%E8%80%85%E9%97%AE%E9%A2%98.jpeg 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%AF%BB%E8%80%85%E9%97%AE%E9%A2%98.jpeg"
        title="img" /></p>
<p>如果你知道 MySQL 一行记录的存储结构，那么这个问题对你没什么难度。</p>
<p>如果你不知道也没关系，这次我跟大家聊聊 <strong>MySQL 一行记录是怎么存储的？</strong></p>
<p>知道了这个之后，除了能应解锁前面这道面试题，你还会解锁这些面试题：</p>
<ul>
<li>MySQL 的 NULL 值会占用空间吗？</li>
<li>MySQL 怎么知道 varchar(n) 实际占用数据的大小？</li>
<li>varchar(n) 中 n 最大取值为多少？</li>
<li>行溢出后，MySQL 是怎么处理的？</li>
</ul>
<p>这些问题看似毫不相干，其实都是在围绕「 MySQL 一行记录的存储结构」这一个知识点，所以攻破了这个知识点后，这些问题就引刃而解了。</p>
<p>好了，话不多说，发车！</p>
<h2 id="httpsxiaolincodingcommysqlbaserow_formathtmlmysql-的数据存放在哪个文件mysql-的数据存放在哪个文件"><a href="https://xiaolincoding.com/mysql/base/row_format.html#mysql-%e7%9a%84%e6%95%b0%e6%8d%ae%e5%ad%98%e6%94%be%e5%9c%a8%e5%93%aa%e4%b8%aa%e6%96%87%e4%bb%b6" target="_blank" rel="noopener noreffer">#</a>MySQL 的数据存放在哪个文件？</h2>
<p>大家都知道 MySQL 的数据都是保存在磁盘的，那具体是保存在哪个文件呢？</p>
<p>MySQL 存储的行为是由存储引擎实现的，MySQL 支持多种存储引擎，不同的存储引擎保存的文件自然也不同。</p>
<p>InnoDB 是我们常用的存储引擎，也是 MySQL 默认的存储引擎。所以，本文主要以 InnoDB 存储引擎展开讨论。</p>
<p>先来看看 MySQL 数据库的文件存放在哪个目录？</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-sql" data-lang="sql"><span class="n">mysql</span><span class="o">&gt;</span><span class="w"> </span><span class="k">SHOW</span><span class="w"> </span><span class="n">VARIABLES</span><span class="w"> </span><span class="k">LIKE</span><span class="w"> </span><span class="s1">&#39;datadir&#39;</span><span class="p">;</span><span class="w">
</span><span class="w"></span><span class="o">+</span><span class="c1">---------------+-----------------+
</span><span class="c1"></span><span class="o">|</span><span class="w"> </span><span class="n">Variable_name</span><span class="w"> </span><span class="o">|</span><span class="w"> </span><span class="n">Value</span><span class="w">           </span><span class="o">|</span><span class="w">
</span><span class="w"></span><span class="o">+</span><span class="c1">---------------+-----------------+
</span><span class="c1"></span><span class="o">|</span><span class="w"> </span><span class="n">datadir</span><span class="w">       </span><span class="o">|</span><span class="w"> </span><span class="o">/</span><span class="n">var</span><span class="o">/</span><span class="n">lib</span><span class="o">/</span><span class="n">mysql</span><span class="o">/</span><span class="w"> </span><span class="o">|</span><span class="w">
</span><span class="w"></span><span class="o">+</span><span class="c1">---------------+-----------------+
</span><span class="c1"></span><span class="mi">1</span><span class="w"> </span><span class="k">row</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="k">set</span><span class="w"> </span><span class="p">(</span><span class="mi">0</span><span class="p">.</span><span class="mi">00</span><span class="w"> </span><span class="n">sec</span><span class="p">)</span><span class="w">
</span></code></pre></div><p>我们每创建一个 database（数据库） 都会在 /var/lib/mysql/ 目录里面创建一个以 database 为名的目录，然后保存表结构和表数据的文件都会存放在这个目录里。</p>
<p>比如，我这里有一个名为 my_test 的 database，该 database 里有一张名为 t_order 数据库表。</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/database.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/database.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/database.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/database.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/database.png"
        title="img" /></p>
<p>然后，我们进入 /var/lib/mysql/my_test 目录，看看里面有什么文件？</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-shell" data-lang="shell"><span class="o">[</span>root@xiaolin ~<span class="o">]</span><span class="c1">#ls /var/lib/mysql/my_test</span>
db.opt  
t_order.frm  
t_order.ibd
</code></pre></div><p>可以看到，共有三个文件，这三个文件分别代表着：</p>
<ul>
<li>db.opt，用来存储当前数据库的默认字符集和字符校验规则。</li>
<li>t_order.frm ，t_order 的<strong>表结构</strong>会保存在这个文件。在 MySQL 中建立一张表都会生成一个.frm 文件，该文件是用来保存每个表的元数据信息的，主要包含表结构定义。</li>
<li>t_order.ibd，t_order 的<strong>表数据</strong>会保存在这个文件。表数据既可以存在共享表空间文件（文件名：ibdata1）里，也可以存放在独占表空间文件（文件名：表名字.ibd）。这个行为是由参数 innodb_file_per_table 控制的，若设置了参数 innodb_file_per_table 为 1，则会将存储的数据、索引等信息单独存储在一个独占表空间，从 MySQL 5.6.6 版本开始，它的默认值就是 1 了，因此从这个版本之后， MySQL 中每一张表的数据都存放在一个独立的 .ibd 文件。</li>
</ul>
<p>好了，现在我们知道了一张数据库表的数据是保存在「 表名字.ibd 」的文件里的，这个文件也称为独占表空间文件。</p>
<h3 id="httpsxiaolincodingcommysqlbaserow_formathtml表空间文件的结构是怎么样的表空间文件的结构是怎么样的"><a href="https://xiaolincoding.com/mysql/base/row_format.html#%e8%a1%a8%e7%a9%ba%e9%97%b4%e6%96%87%e4%bb%b6%e7%9a%84%e7%bb%93%e6%9e%84%e6%98%af%e6%80%8e%e4%b9%88%e6%a0%b7%e7%9a%84" target="_blank" rel="noopener noreffer">#</a>表空间文件的结构是怎么样的？</h3>
<p><strong>表空间由段（segment）、区（extent）、页（page）、行（row）组成</strong>，InnoDB存储引擎的逻辑存储结构大致如下图：</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%A1%A8%E7%A9%BA%E9%97%B4%E7%BB%93%E6%9E%84.drawio.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%A1%A8%E7%A9%BA%E9%97%B4%E7%BB%93%E6%9E%84.drawio.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%A1%A8%E7%A9%BA%E9%97%B4%E7%BB%93%E6%9E%84.drawio.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%A1%A8%E7%A9%BA%E9%97%B4%E7%BB%93%E6%9E%84.drawio.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%A1%A8%E7%A9%BA%E9%97%B4%E7%BB%93%E6%9E%84.drawio.png"
        title="img" /></p>
<p>下面我们从下往上一个个看看。</p>
<h4 id="httpsxiaolincodingcommysqlbaserow_formathtml_1行-row1行row"><a href="https://xiaolincoding.com/mysql/base/row_format.html#_1%e3%80%81%e8%a1%8c-row" target="_blank" rel="noopener noreffer">#</a>1、行（row）</h4>
<p>数据库表中的记录都是按行（row）进行存放的，每行记录根据不同的行格式，有不同的存储结构。</p>
<p>后面我们详细介绍 InnoDB 存储引擎的行格式，也是本文重点介绍的内容。</p>
<h4 id="httpsxiaolincodingcommysqlbaserow_formathtml_2页-page2页page"><a href="https://xiaolincoding.com/mysql/base/row_format.html#_2%e3%80%81%e9%a1%b5-page" target="_blank" rel="noopener noreffer">#</a>2、页（page）</h4>
<p>记录是按照行来存储的，但是数据库的读取并不以「行」为单位，否则一次读取（也就是一次 I/O 操作）只能处理一行数据，效率会非常低。</p>
<p>因此，<strong>InnoDB 的数据是按「页」为单位来读写的</strong>，也就是说，当需要读一条记录的时候，并不是将这个行记录从磁盘读出来，而是以页为单位，将其整体读入内存。</p>
<p><strong>默认每个页的大小为 16KB</strong>，也就是最多能保证 16KB 的连续存储空间。</p>
<p>页是 InnoDB 存储引擎磁盘管理的最小单元，意味着数据库每次读写都是以 16KB 为单位的，一次最少从磁盘中读取 16K 的内容到内存中，一次最少把内存中的 16K 内容刷新到磁盘中。</p>
<p>页的类型有很多，常见的有数据页、undo 日志页、溢出页等等。数据表中的行记录是用「数据页」来管理的，数据页的结构这里我就不讲细说了，之前文章有说过，感兴趣的可以去看这篇文章：<a href="https://xiaolincoding.com/mysql/index/page.html" target="_blank" rel="noopener noreffer">换一个角度看 B+ 树(opens new window)</a></p>
<p>总之知道表中的记录存储在「数据页」里面就行。</p>
<h4 id="httpsxiaolincodingcommysqlbaserow_formathtml_3区-extent3区extent"><a href="https://xiaolincoding.com/mysql/base/row_format.html#_3%e3%80%81%e5%8c%ba-extent" target="_blank" rel="noopener noreffer">#</a>3、区（extent）</h4>
<p>我们知道 InnoDB 存储引擎是用 B+ 树来组织数据的。</p>
<p>B+ 树中每一层都是通过双向链表连接起来的，如果是以页为单位来分配存储空间，那么链表中相邻的两个页之间的物理位置并不是连续的，可能离得非常远，那么磁盘查询时就会有大量的随机I/O，随机 I/O 是非常慢的。</p>
<p>解决这个问题也很简单，就是让链表中相邻的页的物理位置也相邻，这样就可以使用顺序 I/O 了，那么在范围查询（扫描叶子节点）的时候性能就会很高。</p>
<p>那具体怎么解决呢？</p>
<p><strong>在表中数据量大的时候，为某个索引分配空间的时候就不再按照页为单位分配了，而是按照区（extent）为单位分配。每个区的大小为 1MB，对于 16KB 的页来说，连续的 64 个页会被划为一个区，这样就使得链表中相邻的页的物理位置也相邻，就能使用顺序 I/O 了</strong>。</p>
<h4 id="httpsxiaolincodingcommysqlbaserow_formathtml_4段-segment4段segment"><a href="https://xiaolincoding.com/mysql/base/row_format.html#_4%e3%80%81%e6%ae%b5-segment" target="_blank" rel="noopener noreffer">#</a>4、段（segment）</h4>
<p>表空间是由各个段（segment）组成的，段是由多个区（extent）组成的。段一般分为数据段、索引段和回滚段等。</p>
<ul>
<li>索引段：存放 B + 树的非叶子节点的区的集合；</li>
<li>数据段：存放 B + 树的叶子节点的区的集合；</li>
<li>回滚段：存放的是回滚数据的区的集合，之前讲<a href="https://xiaolincoding.com/mysql/transaction/mvcc.html" target="_blank" rel="noopener noreffer">事务隔离 (opens new window)</a>的时候就介绍到了 MVCC 利用了回滚段实现了多版本查询数据。</li>
</ul>
<p>好了，终于说完表空间的结构了。接下来，就具体讲一下 InnoDB 的行格式了。</p>
<p>之所以要绕一大圈才讲行记录的格式，主要是想让大家知道行记录是存储在哪个文件，以及行记录在这个表空间文件中的哪个区域，有一个从上往下切入的视角，这样理解起来不会觉得很抽象。</p>
<h2 id="httpsxiaolincodingcommysqlbaserow_formathtmlinnodb-行格式有哪些innodb-行格式有哪些"><a href="https://xiaolincoding.com/mysql/base/row_format.html#innodb-%e8%a1%8c%e6%a0%bc%e5%bc%8f%e6%9c%89%e5%93%aa%e4%ba%9b" target="_blank" rel="noopener noreffer">#</a>InnoDB 行格式有哪些？</h2>
<p>行格式（row_format），就是一条记录的存储结构。</p>
<p>InnoDB 提供了 4 种行格式，分别是 Redundant、Compact、Dynamic和 Compressed 行格式。</p>
<ul>
<li>Redundant 是很古老的行格式了， MySQL 5.0 版本之前用的行格式，现在基本没人用了。</li>
<li>由于 Redundant 不是一种紧凑的行格式，所以 MySQL 5.0 之后引入了 Compact 行记录存储方式，Compact 是一种紧凑的行格式，设计的初衷就是为了让一个数据页中可以存放更多的行记录，从 MySQL 5.1 版本之后，行格式默认设置成 Compact。</li>
<li>Dynamic 和 Compressed 两个都是紧凑的行格式，它们的行格式都和 Compact 差不多，因为都是基于 Compact 改进一点东西。从 MySQL5.7 版本之后，默认使用 Dynamic 行格式。</li>
</ul>
<p>Redundant 行格式我这里就不讲了，因为现在基本没人用了，这次重点介绍 Compact 行格式，因为 Dynamic 和 Compressed 这两个行格式跟 Compact 非常像。</p>
<p>所以，弄懂了 Compact 行格式，之后你们在去了解其他行格式，很快也能看懂。</p>
<h2 id="httpsxiaolincodingcommysqlbaserow_formathtmlcompact-行格式长什么样compact-行格式长什么样"><a href="https://xiaolincoding.com/mysql/base/row_format.html#compact-%e8%a1%8c%e6%a0%bc%e5%bc%8f%e9%95%bf%e4%bb%80%e4%b9%88%e6%a0%b7" target="_blank" rel="noopener noreffer">#</a>COMPACT 行格式长什么样？</h2>
<p>先跟 Compact 行格式混个脸熟，它长这样：</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/COMPACT.drawio.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/COMPACT.drawio.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/COMPACT.drawio.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/COMPACT.drawio.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/COMPACT.drawio.png"
        title="img" /></p>
<p>可以看到，一条完整的记录分为「记录的额外信息」和「记录的真实数据」两个部分。</p>
<p>接下里，分别详细说下。</p>
<h3 id="httpsxiaolincodingcommysqlbaserow_formathtml记录的额外信息记录的额外信息"><a href="https://xiaolincoding.com/mysql/base/row_format.html#%e8%ae%b0%e5%bd%95%e7%9a%84%e9%a2%9d%e5%a4%96%e4%bf%a1%e6%81%af" target="_blank" rel="noopener noreffer">#</a>记录的额外信息</h3>
<p>记录的额外信息包含 3 个部分：变长字段长度列表、NULL 值列表、记录头信息。</p>
<h4 id="httpsxiaolincodingcommysqlbaserow_formathtml_1-变长字段长度列表1-变长字段长度列表"><a href="https://xiaolincoding.com/mysql/base/row_format.html#_1-%e5%8f%98%e9%95%bf%e5%ad%97%e6%ae%b5%e9%95%bf%e5%ba%a6%e5%88%97%e8%a1%a8" target="_blank" rel="noopener noreffer">#</a>1. 变长字段长度列表</h4>
<p>varchar(n) 和 char(n) 的区别是什么，相信大家都非常清楚，char 是定长的，varchar 是变长的，变长字段实际存储的数据的长度（大小）不固定的。</p>
<p>所以，在存储数据的时候，也要把数据占用的大小存起来，存到「变长字段长度列表」里面，读取数据的时候才能根据这个「变长字段长度列表」去读取对应长度的数据。其他 TEXT、BLOB 等变长字段也是这么实现的。</p>
<p>为了展示「变长字段长度列表」具体是怎么保存「变长字段的真实数据占用的字节数」，我们先创建这样一张表，字符集是 ascii（所以每一个字符占用的 1 字节），行格式是 Compact，t_user 表中 name 和 phone 字段都是变长字段：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-sql" data-lang="sql"><span class="k">CREATE</span><span class="w"> </span><span class="k">TABLE</span><span class="w"> </span><span class="o">`</span><span class="n">t_user</span><span class="o">`</span><span class="w"> </span><span class="p">(</span><span class="w">
</span><span class="w">  </span><span class="o">`</span><span class="n">id</span><span class="o">`</span><span class="w"> </span><span class="nb">int</span><span class="p">(</span><span class="mi">11</span><span class="p">)</span><span class="w"> </span><span class="k">NOT</span><span class="w"> </span><span class="k">NULL</span><span class="p">,</span><span class="w">
</span><span class="w">  </span><span class="o">`</span><span class="n">name</span><span class="o">`</span><span class="w"> </span><span class="nb">VARCHAR</span><span class="p">(</span><span class="mi">20</span><span class="p">)</span><span class="w"> </span><span class="k">DEFAULT</span><span class="w"> </span><span class="k">NULL</span><span class="p">,</span><span class="w">
</span><span class="w">  </span><span class="o">`</span><span class="n">phone</span><span class="o">`</span><span class="w"> </span><span class="nb">VARCHAR</span><span class="p">(</span><span class="mi">20</span><span class="p">)</span><span class="w"> </span><span class="k">DEFAULT</span><span class="w"> </span><span class="k">NULL</span><span class="p">,</span><span class="w">
</span><span class="w">  </span><span class="o">`</span><span class="n">age</span><span class="o">`</span><span class="w"> </span><span class="nb">int</span><span class="p">(</span><span class="mi">11</span><span class="p">)</span><span class="w"> </span><span class="k">DEFAULT</span><span class="w"> </span><span class="k">NULL</span><span class="p">,</span><span class="w">
</span><span class="w">  </span><span class="k">PRIMARY</span><span class="w"> </span><span class="k">KEY</span><span class="w"> </span><span class="p">(</span><span class="o">`</span><span class="n">id</span><span class="o">`</span><span class="p">)</span><span class="w"> </span><span class="k">USING</span><span class="w"> </span><span class="n">BTREE</span><span class="w">
</span><span class="w"></span><span class="p">)</span><span class="w"> </span><span class="n">ENGINE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">InnoDB</span><span class="w"> </span><span class="k">DEFAULT</span><span class="w"> </span><span class="nb">CHARACTER</span><span class="w"> </span><span class="k">SET</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ascii</span><span class="w"> </span><span class="n">ROW_FORMAT</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">COMPACT</span><span class="p">;</span><span class="w">
</span></code></pre></div><p>现在 t_user 表里有这三条记录：</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/t_test.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/t_test.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/t_test.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/t_test.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/t_test.png"
        title="img" /></p>
<p>接下来，我们看看看看这三条记录的行格式中的 「变长字段长度列表」是怎样存储的。</p>
<p>先来看第一条记录：</p>
<ul>
<li>name 列的值为 a，真实数据占用的字节数是 1 字节，十六进制 0x01；</li>
<li>phone 列的值为 123，真实数据占用的字节数是 3 字节，十六进制 0x03；</li>
<li>age 列和 id 列不是变长字段，所以这里不用管。</li>
</ul>
<p>这些变长字段的真实数据占用的字节数会按照列的顺序<strong>逆序存放</strong>（等下会说为什么要这么设计），所以「变长字段长度列表」里的内容是「 03 01」，而不是 「01 03」。</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%8F%98%E9%95%BF%E5%AD%97%E6%AE%B5%E9%95%BF%E5%BA%A6%E5%88%97%E8%A1%A81.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%8F%98%E9%95%BF%E5%AD%97%E6%AE%B5%E9%95%BF%E5%BA%A6%E5%88%97%E8%A1%A81.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%8F%98%E9%95%BF%E5%AD%97%E6%AE%B5%E9%95%BF%E5%BA%A6%E5%88%97%E8%A1%A81.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%8F%98%E9%95%BF%E5%AD%97%E6%AE%B5%E9%95%BF%E5%BA%A6%E5%88%97%E8%A1%A81.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%8F%98%E9%95%BF%E5%AD%97%E6%AE%B5%E9%95%BF%E5%BA%A6%E5%88%97%E8%A1%A81.png"
        title="img" /></p>
<p>同样的道理，我们也可以得出<strong>第二条记录</strong>的行格式中，「变长字段长度列表」里的内容是「 04 02」，如下图：</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%8F%98%E9%95%BF%E5%AD%97%E6%AE%B5%E9%95%BF%E5%BA%A6%E5%88%97%E8%A1%A82.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%8F%98%E9%95%BF%E5%AD%97%E6%AE%B5%E9%95%BF%E5%BA%A6%E5%88%97%E8%A1%A82.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%8F%98%E9%95%BF%E5%AD%97%E6%AE%B5%E9%95%BF%E5%BA%A6%E5%88%97%E8%A1%A82.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%8F%98%E9%95%BF%E5%AD%97%E6%AE%B5%E9%95%BF%E5%BA%A6%E5%88%97%E8%A1%A82.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%8F%98%E9%95%BF%E5%AD%97%E6%AE%B5%E9%95%BF%E5%BA%A6%E5%88%97%E8%A1%A82.png"
        title="img" /></p>
<p><strong>第三条记录</strong>中 phone 列的值是 NULL，<strong>NULL 是不会存放在行格式中记录的真实数据部分里的</strong>，所以「变长字段长度列表」里不需要保存值为 NULL 的变长字段的长度。</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%8F%98%E9%95%BF%E5%AD%97%E6%AE%B5%E9%95%BF%E5%BA%A6%E5%88%97%E8%A1%A83.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%8F%98%E9%95%BF%E5%AD%97%E6%AE%B5%E9%95%BF%E5%BA%A6%E5%88%97%E8%A1%A83.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%8F%98%E9%95%BF%E5%AD%97%E6%AE%B5%E9%95%BF%E5%BA%A6%E5%88%97%E8%A1%A83.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%8F%98%E9%95%BF%E5%AD%97%E6%AE%B5%E9%95%BF%E5%BA%A6%E5%88%97%E8%A1%A83.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%8F%98%E9%95%BF%E5%AD%97%E6%AE%B5%E9%95%BF%E5%BA%A6%E5%88%97%E8%A1%A83.png"
        title="img" /></p>
<blockquote>
<p>为什么「变长字段长度列表」的信息要按照逆序存放？</p>
</blockquote>
<p>这个设计是有想法的，主要是因为「记录头信息」中指向下一个记录的指针，指向的是下一条记录的「记录头信息」和「真实数据」之间的位置，这样的好处是向左读就是记录头信息，向右读就是真实数据，比较方便。</p>
<p>「变长字段长度列表」中的信息之所以要逆序存放，是因为这样可以<strong>使得位置靠前的记录的真实数据和数据对应的字段长度信息可以同时在一个 CPU Cache Line 中，这样就可以提高 CPU Cache 的命中率</strong>。</p>
<p>同样的道理， NULL 值列表的信息也需要逆序存放。</p>
<p>如果你不知道什么是 CPU Cache，可以看<a href="https://xiaolincoding.com/os/1_hardware/how_to_make_cpu_run_faster.html" target="_blank" rel="noopener noreffer">这篇文章 (opens new window)</a>，这属于计算机组成的知识。</p>
<blockquote>
<p>每个数据库表的行格式都有「变长字段字节数列表」吗？</p>
</blockquote>
<p>其实变长字段字节数列表不是必须的。</p>
<p><strong>当数据表没有变长字段的时候，比如全部都是 int 类型的字段，这时候表里的行格式就不会有「变长字段长度列表」了</strong>，因为没必要，不如去掉以节省空间。</p>
<p>所以「变长字段长度列表」只出现在数据表有变长字段的时候。</p>
<h4 id="httpsxiaolincodingcommysqlbaserow_formathtml_2-null-值列表2-null-值列表"><a href="https://xiaolincoding.com/mysql/base/row_format.html#_2-null-%e5%80%bc%e5%88%97%e8%a1%a8" target="_blank" rel="noopener noreffer">#</a>2. NULL 值列表</h4>
<p>表中的某些列可能会存储 NULL 值，如果把这些 NULL 值都放到记录的真实数据中会比较浪费空间，所以 Compact 行格式把这些值为 NULL 的列存储到 NULL值列表中。</p>
<p>如果存在允许 NULL 值的列，则每个列对应一个二进制位（bit），二进制位按照列的顺序逆序排列。</p>
<ul>
<li>二进制位的值为<code>1</code>时，代表该列的值为NULL。</li>
<li>二进制位的值为<code>0</code>时，代表该列的值不为NULL。</li>
</ul>
<p>另外，NULL 值列表必须用整数个字节的位表示（1字节8位），如果使用的二进制位个数不足整数个字节，则在字节的高位补 <code>0</code>。</p>
<p>还是以 t_user 表的这三条记录作为例子：</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/t_test.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/t_test.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/t_test.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/t_test.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/t_test.png"
        title="img" /></p>
<p>接下来，我们看看看看这三条记录的行格式中的 NULL 值列表是怎样存储的。</p>
<p>先来看<strong>第一条记录</strong>，第一条记录所有列都有值，不存在 NULL 值，所以用二进制来表示是酱紫的：</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A81.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A81.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A81.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A81.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A81.png"
        title="img" /></p>
<p>但是 InnoDB 是用整数字节的二进制位来表示 NULL 值列表的，现在不足 8 位，所以要在高位补 0，最终用二进制来表示是酱紫的：</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A82.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A82.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A82.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A82.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A82.png"
        title="img" /></p>
<p>所以，对于第一条数据，NULL 值列表用十六进制表示是 0x00。</p>
<p>接下来看<strong>第二条记录</strong>，第二条记录 age 列是 NULL 值，所以，对于第二条数据，NULL值列表用十六进制表示是 0x04。</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A83.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A83.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A83.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A83.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A83.png"
        title="img" /></p>
<p>最后<strong>第三条记录</strong>，第三条记录 phone 列 和 age 列是 NULL 值，所以，对于第三条数据，NULL 值列表用十六进制表示是 0x06。</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A84.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A84.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A84.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A84.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A84.png"
        title="img" /></p>
<p>我们把三条记录的 NULL 值列表都填充完毕后，它们的行格式是这样的：</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A85.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A85.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A85.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A85.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/null%E5%80%BC%E5%88%97%E8%A1%A85.png"
        title="img" /></p>
<blockquote>
<p>每个数据库表的行格式都有「NULL 值列表」吗？</p>
</blockquote>
<p>NULL 值列表也不是必须的。</p>
<p><strong>当数据表的字段都定义成 NOT NULL 的时候，这时候表里的行格式就不会有 NULL 值列表了</strong>。</p>
<p>所以在设计数据库表的时候，通常都是建议将字段设置为 NOT NULL，这样可以至少节省 1 字节的空间（NULL 值列表至少占用 1 字节空间）。</p>
<blockquote>
<p>「NULL 值列表」是固定 1 字节空间吗？如果这样的话，一条记录有 9 个字段值都是 NULL，这时候怎么表示？</p>
</blockquote>
<p>「NULL 值列表」的空间不是固定 1 字节的。</p>
<p>当一条记录有 9 个字段值都是 NULL，那么就会创建 2 字节空间的「NULL 值列表」，以此类推。</p>
<h4 id="httpsxiaolincodingcommysqlbaserow_formathtml_3-记录头信息3-记录头信息"><a href="https://xiaolincoding.com/mysql/base/row_format.html#_3-%e8%ae%b0%e5%bd%95%e5%a4%b4%e4%bf%a1%e6%81%af" target="_blank" rel="noopener noreffer">#</a>3. 记录头信息</h4>
<p>记录头信息中包含的内容很多，我就不一一列举了，这里说几个比较重要的：</p>
<ul>
<li>delete_mask ：标识此条数据是否被删除。从这里可以知道，我们执行 detele 删除记录的时候，并不会真正的删除记录，只是将这个记录的 delete_mask 标记为 1。</li>
<li>next_record：下一条记录的位置。从这里可以知道，记录与记录之间是通过链表组织的。在前面我也提到了，指向的是下一条记录的「记录头信息」和「真实数据」之间的位置，这样的好处是向左读就是记录头信息，向右读就是真实数据，比较方便。</li>
<li>record_type：表示当前记录的类型，0表示普通记录，1表示B+树非叶子节点记录，2表示最小记录，3表示最大记录</li>
</ul>
<h3 id="httpsxiaolincodingcommysqlbaserow_formathtml记录的真实数据记录的真实数据"><a href="https://xiaolincoding.com/mysql/base/row_format.html#%e8%ae%b0%e5%bd%95%e7%9a%84%e7%9c%9f%e5%ae%9e%e6%95%b0%e6%8d%ae" target="_blank" rel="noopener noreffer">#</a>记录的真实数据</h3>
<p>记录真实数据部分除了我们定义的字段，还有三个隐藏字段，分别为：row_id、trx_id、roll_pointer，我们来看下这三个字段是什么。</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%AE%B0%E5%BD%95%E7%9A%84%E7%9C%9F%E5%AE%9E%E6%95%B0%E6%8D%AE.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%AE%B0%E5%BD%95%E7%9A%84%E7%9C%9F%E5%AE%9E%E6%95%B0%E6%8D%AE.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%AE%B0%E5%BD%95%E7%9A%84%E7%9C%9F%E5%AE%9E%E6%95%B0%E6%8D%AE.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%AE%B0%E5%BD%95%E7%9A%84%E7%9C%9F%E5%AE%9E%E6%95%B0%E6%8D%AE.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%AE%B0%E5%BD%95%E7%9A%84%E7%9C%9F%E5%AE%9E%E6%95%B0%E6%8D%AE.png"
        title="img" /></p>
<ul>
<li>row_id</li>
</ul>
<p>如果我们建表的时候指定了主键或者唯一约束列，那么就没有 row_id 隐藏字段了。如果既没有指定主键，又没有唯一约束，那么 InnoDB 就会为记录添加 row_id 隐藏字段。row_id不是必需的，占用 6 个字节。</p>
<ul>
<li>trx_id</li>
</ul>
<p>事务id，表示这个数据是由哪个事务生成的。 trx_id是必需的，占用 6 个字节。</p>
<ul>
<li>roll_pointer</li>
</ul>
<p>这条记录上一个版本的指针。roll_pointer 是必需的，占用 7 个字节。</p>
<p>如果你熟悉 MVCC 机制，你应该就清楚 trx_id 和 roll_pointer 的作用了，如果你还不知道 MVCC 机制，可以看完<a href="https://xiaolincoding.com/mysql/transaction/mvcc.html" target="_blank" rel="noopener noreffer">这篇文章 (opens new window)</a>，一定要掌握，面试也很经常问 MVCC 是怎么实现的。</p>
<h2 id="httpsxiaolincodingcommysqlbaserow_formathtmlvarchar-n-中-n-最大取值为多少varcharn-中-n-最大取值为多少"><a href="https://xiaolincoding.com/mysql/base/row_format.html#varchar-n-%e4%b8%ad-n-%e6%9c%80%e5%a4%a7%e5%8f%96%e5%80%bc%e4%b8%ba%e5%a4%9a%e5%b0%91" target="_blank" rel="noopener noreffer">#</a>varchar(n) 中 n 最大取值为多少？</h2>
<p>我们要清楚一点，<strong>MySQL 规定除了 TEXT、BLOBs 这种大对象类型之外，其他所有的列（不包括隐藏列和记录头信息）占用的字节长度加起来不能超过 65535 个字节</strong>。</p>
<p>也就是说，一行记录除了 TEXT、BLOBs 类型的列，限制最大为 65535 字节，注意是一行的总长度，不是一列。</p>
<p>知道了这个前提之后，我们再来看看这个问题：「varchar(n) 中 n 最大取值为多少？」</p>
<p>varchar(n) 字段类型的 n 代表的是最多存储的字符数量，并不是字节大小哦。</p>
<p>要算 varchar(n) 最大能允许存储的字节数，还要看数据库表的字符集，因为字符集代表着，1个字符要占用多少字节，比如 ascii 字符集， 1 个字符占用 1 字节，那么 varchar(100) 意味着最大能允许存储 100 字节的数据。</p>
<h3 id="httpsxiaolincodingcommysqlbaserow_formathtml单字段的情况单字段的情况"><a href="https://xiaolincoding.com/mysql/base/row_format.html#%e5%8d%95%e5%ad%97%e6%ae%b5%e7%9a%84%e6%83%85%e5%86%b5" target="_blank" rel="noopener noreffer">#</a>单字段的情况</h3>
<p>前面我们知道了，一行记录最大只能存储 65535 字节的数据。</p>
<p>那假设数据库表只有一个 varchar(n) 类型的列且字符集是 ascii，在这种情况下， varchar(n) 中 n 最大取值是 65535 吗？</p>
<p>不着急说结论，我们先来做个实验验证一下。</p>
<p>我们定义一个 varchar(65535) 类型的字段，字符集为 ascii 的数据库表。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-sql" data-lang="sql"><span class="k">CREATE</span><span class="w"> </span><span class="k">TABLE</span><span class="w"> </span><span class="n">test</span><span class="w"> </span><span class="p">(</span><span class="w"> 
</span><span class="w"></span><span class="o">`</span><span class="n">name</span><span class="o">`</span><span class="w"> </span><span class="nb">VARCHAR</span><span class="p">(</span><span class="mi">65535</span><span class="p">)</span><span class="w">  </span><span class="k">NULL</span><span class="w">
</span><span class="w"></span><span class="p">)</span><span class="w"> </span><span class="n">ENGINE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">InnoDB</span><span class="w"> </span><span class="k">DEFAULT</span><span class="w"> </span><span class="nb">CHARACTER</span><span class="w"> </span><span class="k">SET</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ascii</span><span class="w"> </span><span class="n">ROW_FORMAT</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">COMPACT</span><span class="p">;</span><span class="w">
</span></code></pre></div><p>看能不能成功创建一张表：</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/error.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/error.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/error.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/error.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/error.png"
        title="img" /></p>
<p>可以看到，创建失败了。</p>
<p>从报错信息就可以知道<strong>一行数据的最大字节数是 65535（不包含 TEXT、BLOBs 这种大对象类型），其中包含了 storage overhead</strong>。</p>
<p>问题来了，这个 storage overhead 是什么呢？其实就是「变长字段长度列表」和 「NULL 值列表」，也就是说<strong>一行数据的最大字节数 65535，其实是包含「变长字段长度列表」和 「NULL 值列表」所占用的字节数的</strong>。所以， 我们在算 varchar(n) 中 n 最大值时，需要减去 storage overhead 占用的字节数。</p>
<p>这是因为我们存储字段类型为 varchar(n) 的数据时，其实分成了三个部分来存储：</p>
<ul>
<li>真实数据</li>
<li>真实数据占用的字节数</li>
<li>NULL 标识，如果不允许为NULL，这部分不需要</li>
</ul>
<blockquote>
<p>本次案例中，「NULL 值列表」所占用的字节数是多少？</p>
</blockquote>
<p>前面我创建表的时候，字段是允许为 NULL 的，所以<strong>会用 1 字节来表示「NULL 值列表」</strong>。</p>
<blockquote>
<p>本次案例中，「变长字段长度列表」所占用的字节数是多少？</p>
</blockquote>
<p>「变长字段长度列表」所占用的字节数 = 所有「变长字段长度」占用的字节数之和。</p>
<p>所以，我们要先知道每个变长字段的「变长字段长度」需要用多少字节表示？具体情况分为：</p>
<ul>
<li>条件一：如果变长字段允许存储的最大字节数小于等于 255 字节，就会用 1 字节表示「变长字段长度」；</li>
<li>条件二：如果变长字段允许存储的最大字节数大于 255 字节，就会用 2 字节表示「变长字段长度」；</li>
</ul>
<p>我们这里字段类型是 varchar(65535) ，字符集是 ascii，所以代表着变长字段允许存储的最大字节数是 65535，符合条件二，所以会用 2 字节来表示「变长字段长度」。</p>
<p><strong>因为我们这个案例是只有 1 个变长字段，所以「变长字段长度列表」= 1 个「变长字段长度」占用的字节数，也就是 2 字节</strong>。</p>
<p>因为我们在算 varchar(n) 中 n 最大值时，需要减去 「变长字段长度列表」和 「NULL 值列表」所占用的字节数的。所以，<strong>在数据库表只有一个 varchar(n) 字段且字符集是 ascii 的情况下，varchar(n) 中 n 最大值 = 65535 - 2 - 1 = 65532</strong>。</p>
<p>我们先来测试看看 varchar(65533) 是否可行？</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/65533.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/65533.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/65533.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/65533.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/65533.png"
        title="img" /></p>
<p>可以看到，还是不行，接下来看看 varchar(65532) 是否可行？</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/65532.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/65532.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/65532.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/65532.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/65532.png"
        title="img" /></p>
<p>可以看到，创建成功了。说明我们的推论是正确的，在算 varchar(n) 中 n 最大值时，需要减去 「变长字段长度列表」和 「NULL 值列表」所占用的字节数的。</p>
<p>当然，我上面这个例子是针对字符集为 ascii 情况，如果采用的是 UTF-8，varchar(n) 最多能存储的数据计算方式就不一样了：</p>
<ul>
<li>在 UTF-8 字符集下，一个字符最多需要三个字节，varchar(n) 的 n 最大取值就是 65532/3 = 21844。</li>
</ul>
<p>上面所说的只是针对于一个字段的计算方式。</p>
<h3 id="httpsxiaolincodingcommysqlbaserow_formathtml多字段的情况多字段的情况"><a href="https://xiaolincoding.com/mysql/base/row_format.html#%e5%a4%9a%e5%ad%97%e6%ae%b5%e7%9a%84%e6%83%85%e5%86%b5" target="_blank" rel="noopener noreffer">#</a>多字段的情况</h3>
<p><strong>如果有多个字段的话，要保证所有字段的长度 + 变长字段字节数列表所占用的字节数 + NULL值列表所占用的字节数 &lt;= 65535</strong>。</p>
<p>这里举个多字段的情况的例子（感谢@Emoji同学提供的例子）</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%A4%9A%E5%AD%97%E6%AE%B5%E7%9A%84%E6%83%85%E5%86%B5.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%A4%9A%E5%AD%97%E6%AE%B5%E7%9A%84%E6%83%85%E5%86%B5.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%A4%9A%E5%AD%97%E6%AE%B5%E7%9A%84%E6%83%85%E5%86%B5.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%A4%9A%E5%AD%97%E6%AE%B5%E7%9A%84%E6%83%85%E5%86%B5.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E5%A4%9A%E5%AD%97%E6%AE%B5%E7%9A%84%E6%83%85%E5%86%B5.png"
        title="img" /></p>
<h2 id="httpsxiaolincodingcommysqlbaserow_formathtml行溢出后-mysql-是怎么处理的行溢出后mysql-是怎么处理的"><a href="https://xiaolincoding.com/mysql/base/row_format.html#%e8%a1%8c%e6%ba%a2%e5%87%ba%e5%90%8e-mysql-%e6%98%af%e6%80%8e%e4%b9%88%e5%a4%84%e7%90%86%e7%9a%84" target="_blank" rel="noopener noreffer">#</a>行溢出后，MySQL 是怎么处理的？</h2>
<p>MySQL 中磁盘和内存交互的基本单位是页，一个页的大小一般是 <code>16KB</code>，也就是 <code>16384字节</code>，而一个 varchar(n) 类型的列最多可以存储 <code>65532字节</code>，一些大对象如 TEXT、BLOB 可能存储更多的数据，这时一个页可能就存不了一条记录。这个时候就会<strong>发生行溢出，多的数据就会存到另外的「溢出页」中</strong>。</p>
<p>如果一个数据页存不了一条记录，InnoDB 存储引擎会自动将溢出的数据存放到「溢出页」中。在一般情况下，InnoDB 的数据都是存放在 「数据页」中。但是当发生行溢出时，溢出的数据会存放到「溢出页」中。</p>
<p>当发生行溢出时，在记录的真实数据处只会保存该列的一部分数据，而把剩余的数据放在「溢出页」中，然后真实数据处用 20 字节存储指向溢出页的地址，从而可以找到剩余数据所在的页。大致如下图所示。</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%A1%8C%E6%BA%A2%E5%87%BA.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%A1%8C%E6%BA%A2%E5%87%BA.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%A1%8C%E6%BA%A2%E5%87%BA.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%A1%8C%E6%BA%A2%E5%87%BA.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%A1%8C%E6%BA%A2%E5%87%BA.png"
        title="img" /></p>
<p>上面这个是 Compact 行格式在发生行溢出后的处理。</p>
<p>Compressed 和 Dynamic 这两个行格式和 Compact 非常类似，主要的区别在于处理行溢出数据时有些区别。</p>
<p>这两种格式采用完全的行溢出方式，记录的真实数据处不会存储该列的一部分数据，只存储 20 个字节的指针来指向溢出页。而实际的数据都存储在溢出页中，看起来就像下面这样：</p>
<p><img
        class="lazyload"
        src="/svg/loading.min.svg"
        data-src="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%A1%8C%E6%BA%A2%E5%87%BA2.png"
        data-srcset="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%A1%8C%E6%BA%A2%E5%87%BA2.png, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%A1%8C%E6%BA%A2%E5%87%BA2.png 1.5x, https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%A1%8C%E6%BA%A2%E5%87%BA2.png 2x"
        data-sizes="auto"
        alt="https://cdn.xiaolincoding.com/gh/xiaolincoder/mysql/row_format/%E8%A1%8C%E6%BA%A2%E5%87%BA2.png"
        title="img" /></p>
<h2 id="httpsxiaolincodingcommysqlbaserow_formathtml总结总结"><a href="https://xiaolincoding.com/mysql/base/row_format.html#%e6%80%bb%e7%bb%93" target="_blank" rel="noopener noreffer">#</a>总结</h2>
<blockquote>
<p>MySQL 的 NULL 值是怎么存放的？</p>
</blockquote>
<p>MySQL 的 Compact 行格式中会用「NULL值列表」来标记值为 NULL 的列，NULL 值并不会存储在行格式中的真实数据部分。</p>
<p>NULL值列表会占用 1 字节空间，当表中所有字段都定义成 NOT NULL，行格式中就不会有 NULL值列表，这样可节省 1 字节的空间。</p>
<blockquote>
<p>MySQL 怎么知道 varchar(n) 实际占用数据的大小？</p>
</blockquote>
<p>MySQL 的 Compact 行格式中会用「变长字段长度列表」存储变长字段实际占用的数据大小。</p>
<blockquote>
<p>varchar(n) 中 n 最大取值为多少？</p>
</blockquote>
<p>一行记录最大能存储 65535 字节的数据，但是这个是包含「变长字段字节数列表所占用的字节数」和「NULL值列表所占用的字节数」。所以， 我们在算 varchar(n) 中 n 最大值时，需要减去这两个列表所占用的字节数。</p>
<p>如果一张表只有一个 varchar(n) 字段，且允许为 NULL，字符集为 ascii。varchar(n) 中 n 最大取值为 65532。</p>
<p>计算公式：65535 - 变长字段字节数列表所占用的字节数 - NULL值列表所占用的字节数 = 65535 - 2 - 1 = 65532。</p>
<p>如果有多个字段的话，要保证所有字段的长度 + 变长字段字节数列表所占用的字节数 + NULL值列表所占用的字节数 &lt;= 65535。</p>
<blockquote>
<p>行溢出后，MySQL 是怎么处理的？</p>
</blockquote>
<p>如果一个数据页存不了一条记录，InnoDB 存储引擎会自动将溢出的数据存放到「溢出页」中。</p>
<p>Compact 行格式针对行溢出的处理是这样的：当发生行溢出时，在记录的真实数据处只会保存该列的一部分数据，而把剩余的数据放在「溢出页」中，然后真实数据处用 20 字节存储指向溢出页的地址，从而可以找到剩余数据所在的页。</p>
<p>Compressed 和 Dynamic 这两种格式采用完全的行溢出方式，记录的真实数据处不会存储该列的一部分数据，只存储 20 个字节的指针来指向溢出页。而实际的数据都存储在溢出页中。</p>
<p>参考资料：</p>
<ul>
<li>《MySQL 是怎样运行的》</li>
<li>《MySQL技术内幕 InnoDB存储引擎》</li>
</ul>
</div><div class="post-footer" id="post-footer">
    <div class="post-info"><div class="post-info-tag"><span><a href="/tags/%E4%BA%8Cmysql%E4%B8%80%E6%9D%A1%E8%AE%B0%E5%BD%95%E6%80%8E%E4%B9%88%E5%AD%98%E5%82%A8%E7%9A%84/">二、MySQL一条记录怎么存储的？</a>
                </span></div><div class="post-info-line"><div class="post-info-mod">
                <span>更新于 2023-05-27</span>
            </div><div class="post-info-mod"></div>
        </div><div class="post-info-share">
            <span><a href="javascript:void(0);" title="分享到 Twitter" data-sharer="twitter" data-url="https://acking-you.github.io/posts/%E4%BA%8Cmysql%E4%B8%80%E6%9D%A1%E8%AE%B0%E5%BD%95%E6%80%8E%E4%B9%88%E5%AD%98%E5%82%A8%E7%9A%84/" data-title="二、MySQL一条记录怎么存储的？" data-hashtags="二、MySQL一条记录怎么存储的？"><i class="fab fa-twitter fa-fw"></i></a><a href="javascript:void(0);" title="分享到 Facebook" data-sharer="facebook" data-url="https://acking-you.github.io/posts/%E4%BA%8Cmysql%E4%B8%80%E6%9D%A1%E8%AE%B0%E5%BD%95%E6%80%8E%E4%B9%88%E5%AD%98%E5%82%A8%E7%9A%84/" data-hashtag="二、MySQL一条记录怎么存储的？"><i class="fab fa-facebook-square fa-fw"></i></a><a href="javascript:void(0);" title="分享到 WhatsApp" data-sharer="whatsapp" data-url="https://acking-you.github.io/posts/%E4%BA%8Cmysql%E4%B8%80%E6%9D%A1%E8%AE%B0%E5%BD%95%E6%80%8E%E4%B9%88%E5%AD%98%E5%82%A8%E7%9A%84/" data-title="二、MySQL一条记录怎么存储的？" data-web><i class="fab fa-whatsapp fa-fw"></i></a><a href="javascript:void(0);" title="分享到 Line" data-sharer="line" data-url="https://acking-you.github.io/posts/%E4%BA%8Cmysql%E4%B8%80%E6%9D%A1%E8%AE%B0%E5%BD%95%E6%80%8E%E4%B9%88%E5%AD%98%E5%82%A8%E7%9A%84/" data-title="二、MySQL一条记录怎么存储的？"><i class="fab fa-line fa-fw"></i></a><a href="javascript:void(0);" title="分享到 微博" data-sharer="weibo" data-url="https://acking-you.github.io/posts/%E4%BA%8Cmysql%E4%B8%80%E6%9D%A1%E8%AE%B0%E5%BD%95%E6%80%8E%E4%B9%88%E5%AD%98%E5%82%A8%E7%9A%84/" data-title="二、MySQL一条记录怎么存储的？" data-image="https://img-blog.csdnimg.cn/img_convert/daefa95e021376b822b5938e65b8252b.png#pic_center"><i class="fab fa-weibo fa-fw"></i></a><a href="javascript:void(0);" title="分享到 Myspace" data-sharer="myspace" data-url="https://acking-you.github.io/posts/%E4%BA%8Cmysql%E4%B8%80%E6%9D%A1%E8%AE%B0%E5%BD%95%E6%80%8E%E4%B9%88%E5%AD%98%E5%82%A8%E7%9A%84/" data-title="二、MySQL一条记录怎么存储的？" data-description="二、MySQL一条记录怎么存储的？"><i data-svg-src="/lib/simple-icons/icons/myspace.min.svg"></i></a><a href="javascript:void(0);" title="分享到 Blogger" data-sharer="blogger" data-url="https://acking-you.github.io/posts/%E4%BA%8Cmysql%E4%B8%80%E6%9D%A1%E8%AE%B0%E5%BD%95%E6%80%8E%E4%B9%88%E5%AD%98%E5%82%A8%E7%9A%84/" data-title="二、MySQL一条记录怎么存储的？" data-description="二、MySQL一条记录怎么存储的？"><i class="fab fa-blogger fa-fw"></i></a><a href="javascript:void(0);" title="分享到 Evernote" data-sharer="evernote" data-url="https://acking-you.github.io/posts/%E4%BA%8Cmysql%E4%B8%80%E6%9D%A1%E8%AE%B0%E5%BD%95%E6%80%8E%E4%B9%88%E5%AD%98%E5%82%A8%E7%9A%84/" data-title="二、MySQL一条记录怎么存储的？"><i class="fab fa-evernote fa-fw"></i></a></span>
        </div></div><div class="post-nav"><a href="/posts/%E5%A4%9A%E7%BA%BF%E7%A8%8B%E5%86%B2%E7%AA%81%E4%BA%86%E6%80%8E%E4%B9%88%E5%8A%9E/" class="prev" rel="prev" title="二、多线程冲突了怎么办"><i class="fas fa-angle-left fa-fw"></i>Previous Post</a>
            <a href="/posts/%E8%BF%9B%E7%A8%8B%E9%97%B4%E9%80%9A%E4%BF%A1%E6%96%B9%E5%BC%8F/" class="next" rel="next" title="三、进程间通信方式">Next Post<i class="fas fa-angle-right fa-fw"></i></a></div></div>
</div></article></div>
            </main>
            <footer class="footer"><div class="footer-container"><div class="footer-line">由 <a href="https://gohugo.io/" target="_blank" rel="noopener noreffer" title="Hugo 0.86.0">Hugo</a> 强力驱动 | 主题 - <a href="https://github.com/khusika/FeelIt" target="_blank" rel="noopener noreffer" title="FeelIt 1.0.1"><i class="fas fa-hand-holding-heart fa-fw"></i> FeelIt</a>
        </div><div class="footer-line" itemscope itemtype="http://schema.org/CreativeWork"><i class="far fa-copyright fa-fw"></i><span itemprop="copyrightYear">2023</span><span class="author" itemprop="copyrightHolder">&nbsp;<a href="/"></a></span></div>
</div>
</footer>
        </div>

        <div id="fixed-buttons"><a href="#" id="back-to-top" class="fixed-button" title="回到顶部">
                <i class="fas fa-chevron-up fa-fw"></i>
            </a></div><link rel="stylesheet" href="/lib/fontawesome-free/all.min.css"><link rel="stylesheet" href="/lib/animate/animate.min.css"><link rel="stylesheet" href="/lib/katex/katex.min.css"><link rel="stylesheet" href="/lib/katex/copy-tex.min.css"><script src="/lib/autocomplete/autocomplete.min.js"></script><script src="/lib/lunr/lunr.min.js"></script><script src="/lib/lunr/lunr.stemmer.support.min.js"></script><script src="/lib/lunr/lunr.zh.min.js"></script><script src="/lib/lazysizes/lazysizes.min.js"></script><script src="/lib/clipboard/clipboard.min.js"></script><script src="/lib/sharer/sharer.min.js"></script><script src="/lib/katex/katex.min.js"></script><script src="/lib/katex/auto-render.min.js"></script><script src="/lib/katex/copy-tex.min.js"></script><script src="/lib/katex/mhchem.min.js"></script><script>window.config={"code":{"copyTitle":"复制到剪贴板","maxShownLines":200},"comment":{},"math":{"delimiters":[{"display":true,"left":"$$","right":"$$"},{"display":true,"left":"\\[","right":"\\]"},{"display":false,"left":"$","right":"$"},{"display":false,"left":"\\(","right":"\\)"}],"strict":false},"search":{"highlightTag":"em","lunrIndexURL":"/index.json","lunrLanguageCode":"zh","lunrSegmentitURL":"/lib/lunr/lunr.segmentit.js","maxResultLength":100,"noResultsFound":"没有找到结果","snippetLength":50,"type":"lunr"}};</script><script src="/js/theme.min.js"></script></body></html>
